package Test;

import java.util.Arrays;


public class JAVA {
        public static boolean threeConsecutiveOdds(int[] arr) {
            // 遍历数组，但不包括最后两个元素，因为我们需要检查三个连续的元素
            for (int i = 0; i < arr.length - 2; i++) {
                // 使用位运算判断当前元素及其后两个元素是否都是奇数
                // 奇数的最后一个位是1，偶数的最后一个位是0
                // 因此，奇数与1做位与运算的结果是1，偶数与1做位与运算的结果是0
                if ((arr[i] & 1) == 1 && (arr[i + 1] & 1) == 1 && (arr[i + 2] & 1) == 1) {
                    // 如果三个连续元素都是奇数，返回true
                    return true;
                }
            }
            // 如果没有找到连续三个奇数，返回false
            return false;
        }

        public static void main9(String[] args) {
            int[] arr = {1, 2, 34, 3, 4, 5, 7, 23, 12};
            boolean result = threeConsecutiveOdds(arr);
            System.out.println("存在连续三个奇数: " + result);
        }

    public static int majorityElement(int[] nums) {
            int candidate = 0;
            int count = 0;
            for (int num : nums) {
                if (count == 0) {
                    candidate = num;
                }
                count += (num == candidate) ? 1 : -1;
            }
            return candidate;
        }

        public static void main7(String[] args) {
            int[] nums = {2, 2, 2, 2, 3, 3, 3,3,3};
            int ret = majorityElement(nums);
            System.out.println(ret);
        }

    //给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。
    // 找出那个只出现了一次的元素。
    //题解任何数和0做异或运算，结果仍然是原来的数，即 a ^ 0 = a。
    //任何数和其自身做异或运算，结果是0，即 a ^ a = 0。
    //异或运算满足交换律和结合律，即 a ^ b ^ a = (a ^ a) ^ b = 0 ^ b = b。
    //根据这些性质，我们可以将数组中的所有元素进行异或运算，成对的元素将会相互抵消，
    // 最终剩下的结果就是只出现一次的那个元素。
    public static int Chinge(int[] arryr) {
        int result = 0;
        for (int num : arryr) {
            result ^= num;
        }

        return result;
    }


    public static void main6(String[] args) {
        int[] arryr = {4,4,3,9,3,9,5};//数据示例
        int ret = Chinge(arryr);
        System.out.println(ret);

    }
    public static int[] Aundet(int[] arryr,int target) {
//给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值target的那两个整数，并返回它们的数组下标。
//你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
//你可以按任意顺序返回答案。
//输入：nums = [2,7,11,15], target = 9
//
//输出：[0,1]
//
//解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
        int[] ret = new int[2];
        for (int i = 0; i < arryr.length - 1; i++) {
            for (int j = 0; j < arryr.length-1-i; j++) {
                if (arryr[i] + arryr[j] == target) {
                    ret = new int[]{i, j};
                    return ret;
            }
            }
        }
        return ret;
    }
    public static void main(String[] args) {
        int[] arryr = {2,7,13,25,11,24,45,9};//数据示例
        int[] ret = Aundet(arryr , 45);
        System.out.println(Arrays.toString(ret));

    }
    //冒泡排序
    public static void bubbleSort(int[] arryr){
        //确定趟数
        boolean flg = false;
        for (int i = 0; i < arryr.length - 1; i++) {
            //确定次数
            for (int j = 0; j < arryr.length - 1 -i; j++) {
                //排成升序
                if (arryr[j] > arryr[j + 1]) {
                    int tmp = arryr[j];
                    arryr[j] = arryr[j + 1];
                    arryr[j + 1] = tmp;
                    flg = true;
                }
            }
            if (flg == false) {
                return ;
            }
        }
    }

    public static void main4(String[] args) {
        int[] arr = {1,2,11,45,48,998,77,1000,1234};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));

    }
    //给定一个有序整型数组, 实现二分查找
    public static int fund(int[] arryr, int key){

        int left = 0;
        int right = arryr.length - 1;
        while (left <= right){
            int tmp = (left + right)/2;
            if (key > arryr[tmp]) {
                //右侧查找
                left += 1;
            }
            else if (key < arryr[tmp]) {
                //左侧查找
                right -= 1;
            }
            else
                //找到了
            return tmp;
        }

        return -1;
    }
    public static void main3(String[] args) {

        int[] arryr = {1,2,3,4,5,6,8,99};//数据示例
        int ret = fund(arryr , 6);
        System.out.println(ret);
    }



//调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。

//如数组：[1,2,3,4,5,6]
//
//调整后可能是：[1, 5, 3, 4, 2, 6]
    public static void funding(int[] arryr) {
            int left = 0;
            int right = arryr.length -1;
            while (left < right){
                //1,2,3,5,6,8,7,9,10
                while (left < right && arryr[left] % 2!=0){
                    left++;

                }
                while (left < right && arryr[right] % 2 == 0){
                    right--;
                }
                swap(arryr ,left ,right );
            }
    }

    public static void swap(int[] arryr,int i, int j){
            int tmp = arryr[i];
            arryr[i] = arryr[j];
            arryr[j] = tmp;
    }
    public static void main10(String[] args) {

        int[] arryr = new int[]{1,2,3,5,6,8,7,9,10};//数据示例
        funding(arryr);
        System.out.println(Arrays.toString(arryr));
    }


    //实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上.
//例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
    public static int[]  transform(int[] arryr){
        for (int i = 0; i < arryr.length; i++) {
            arryr[i] *= 2;
        }
        return arryr;
    }
    public static void main1(String[] args) {
        int[] arryr = {1,2,3,4};
        int[] ret = transform(arryr);
        System.out.println(Arrays.toString(arryr));

    }
}
